// // 基础类型

// let a: boolean = true;
// let b: string = `asd${123}`
// let c: number[] = [1, 2, 3] // 数字数组
// let d: any[] = [1, 'h', { x: 5 }, [0, 0]]

// // Tuple 是指成员数量和类型都已知的数组
// let e: [string, number] = ['asd', 123]

// // 接口 (可以理解成为一个模具)
// interface Abc {
//   // age?: number; // 加上 ? 之后在声明变量时不声明不会报错
//   // readonly name: string // 加上readonly表示只读，不会被更改
//   [propName: string]: any // 预设变量
// }
// // 在我们声明dog变量的时候会按照Abc
// // 接口来检测dog的数据类型和对应的数据类型
// let dog: Abc = {
//   age: 3,
//   name: 'mantou',
//   color: 'red',
//   rio: 123,
//   bl: true,
// }
// dog.age = 123


// interface Fn1 {
//   (arg1: string, arg2: number): boolean
//   // (声明的是函数会接受的参数) : 返回的值的类型
// }

// let s1: Fn1;
// s1 = function (arg1, arg2) { // 这个地方的传入参数名可以自定义,如(k1,k2)

//   return true
// }

// s1('abc', 5)



// interface B1 {
//   k: string
// }

// interface B2 {
//   c: boolean
// }

// interface Blchild extends B1, B2 { // Blchild 继承 B1,B2
//   f: number
// }

// let kk: Blchild = {
//   f: 123,
//   k: 'abc',
//   c: true
// }

// class
// class Abb {
//   // 声明可能被使用到的变量
//   // public - 公共 private - 私有 protect - ？  static - 静态
//   // 如果没有指定 性质 那么都默认是 public
//   private arg1: string;
//   static arg2: string = "i miss you" // 不需要new实例就可以直接访问
//   fn2: any
//   // constructor 构造器函数
//   // 这个函数的参数 就是 new对象的时候传入的参数
//   // 调用 new 会先让这个构造器函数执行
//   constructor(param1: string) {
//     this.arg1 = param1
//     this.fn2 = function () { // 这个函数需要先声明
//       console.log(222)
//     }
//   }
//   fn1() {
//     console.log(111)
//   }
// }
// const cctv = new Abb('eee')
// console.log(cctv)
// // Abb.fn1()
// console.log(Abb.arg2, cctv.fn2)


// class aa {
//   a: any;
//   protected b: any
//   constructor() {
//     this.a = 123
//     this.b = 456
//   }
// }
// class bb extends aa {
//   c: any
//   d: any
//   constructor() {
//     super() // super 指的是执行父类当中的constructor()
//     this.c = 789
//     this.d = () => {
//       console.log(this.b)
//     }
//   }
// }

// let a1 = new bb()
// console.log(a1.d())


// let fn1 = function (arg1: string, arg2 = 456, arg3?: string): number {
//   console.log(arg2)
//   return 123
// }
// fn1('asd') // 第三个参数声明时打上了 ? 所以这里可有可无，第二个参数声明时已经进行赋值
// let fn1 = function (arg1: string, arg2 = 456, ...arg3: any[]): number {
//   console.log(arg3)
//   return 123
// }
// fn1('asd', 555, 5, 6, 3, 4, { h: 555 }, '456123') 

// <泛型变量名>(参数1:参数类型, 参数2:泛型变量名):泛型变量名
// function fn2<T>(arg4: T): T {
//   return arg4
// }
// fn2<number>(100)// 第一种方式，先确定数据类型
// fn2(10) // fn2(arg4:number):number

// 枚举 enum

// enum Direction {
//   up,
//   down,
//   left,
//   right = '右' // 可以赋值
// }

// console.log(Direction.right)


// let gg: string | number = 123
// let hh: number | boolean = true

// let a = Symbol()
// let q = Symbol()


// let h = {
//   [a]: 123,
// }

// let k = {
//   a: 456,
//   [q]: 789
// }

// console.log({ ...h, ...k })

import './modl'
import { A } from './mod2'
let kfc: Util.A = {
  name: 'asdf',
  age: 123
}



